package com.zingrow.web.report.service.impl;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
//import java.util.HashSet;
import java.util.List;
import java.util.Map;
//import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zingrow.common.exception.NumberErrorException;
import com.zingrow.common.utils.MongoHelper;
import com.zingrow.web.configure.iformation.service.IIformationService;
import com.zingrow.web.entity.InformationDistribute;
import com.zingrow.web.report.base.Cycle;
import com.zingrow.web.report.mapper.DimensionCountMapper;
import com.zingrow.web.report.model.DimensionBbsRanking;
import com.zingrow.web.report.model.DimensionChannel;
import com.zingrow.web.report.model.DimensionDomain;
import com.zingrow.web.report.model.DimensionNewsRanking;
import com.zingrow.web.report.model.DimensionPlan;
import com.zingrow.web.report.model.DimensionPlanRanking;
import com.zingrow.web.report.model.DimensionWeiboRanking;
import com.zingrow.web.report.model.DimensionWeixinRanking;
import com.zingrow.web.report.service.IRptStatisticsService;
import com.zingrow.web.report.utils.ReportUtils;

@Service
public class RptStatisticsServiceImpl implements IRptStatisticsService {

	MongoHelper mongo = MongoHelper.getInstance();

	Logger logger = LoggerFactory.getLogger(RptStatisticsServiceImpl.class);

	SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");

	@Autowired
	private DimensionCountMapper dimensionCountMapper;

	@Autowired
	private IIformationService iformationService;

	/**
	 * 新增数据到站点维度统计表<br>
	 * ifmIds为Null默认统计所有方案 StartTime、endTime 为Null默认统计时间为当前时间头一天零点开始到当前时间零点结束的信息
	 * <br>
	 * cycleNum: 1日报 2周报 3月报
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean insterDimensionDomain(List<Integer> ifmIds, Date StartTime, Date endTime, Integer cycleNum)
			throws NumberErrorException {
		String type = "";
		switch (cycleNum) {
		case 1:
			type = Cycle.DAY.getName();
			break;
		case 2:
			type = Cycle.WEEK.getName();
			break;
		case 3:
			type = Cycle.MONTH.getName();
			break;
		}
		List<DimensionDomain> DimensionDomainList = new ArrayList<>();// 站点维度
		Date DBTime = new Date();
		Long DBstartTime = ReportUtils.getStart(DBTime, 1);// 当前时间头一天零点
		Date date = new Date(DBstartTime);// 日志变量
		Long DBendTime = ReportUtils.getEnd(DBTime);// 当前时间零点
		List<Integer> DBifmIds = new ArrayList<Integer>();// 方案ID集合
		if (StartTime != null && endTime == null) {
			logger.info("结束时间不允许为空！");
			return false;
		}
		if (StartTime == null && endTime != null) {
			logger.info("开始时间不允许为空！");
			return false;
		}
		if (ifmIds.isEmpty()) {// 没有传入需要统计的方案就默认统计所有
			DBifmIds = iformationService.getAllId();// 获取所有的方案ID
			// 如果传入了时间，就统计传入时间信息，没有传入就默认查询当前时间头一天零点开始到当前时间零点的信息
			DimensionDomainList = mongo.StatisticsDomain(InformationDistribute.class, DBifmIds,
					StartTime != null ? ReportUtils.getStart(StartTime, 0) : DBstartTime,
					endTime != null ? ReportUtils.getStart(endTime, -1) : DBendTime, cycleNum);
		} else {
			DimensionDomainList = mongo.StatisticsDomain(InformationDistribute.class, ifmIds,
					StartTime != null ? ReportUtils.getStart(StartTime, 0) : DBstartTime,
					endTime != null ? ReportUtils.getStart(endTime, -1) : DBendTime, cycleNum);
		}
		if (DimensionDomainList.size() > 0) {
			// 删除老数据
			List<Long> idList = new ArrayList<Long>();
			for (DimensionDomain dimensionDomainId : DimensionDomainList) {
				idList.add(dimensionDomainId.getId());
			}
			if (idList != null && idList.size() > 0) {
				dimensionCountMapper.deleteDomainById(idList);
			}
			int i = 0;
			for (DimensionDomain dimensionDomain : DimensionDomainList) {
				try {
					dimensionCountMapper.insertDomain(dimensionDomain);
					logger.info(String.format("统计站点：%s,统计的方案ID：%s,原创数：%s,转载数：%s,报告类型：%s报",
							dimensionDomain.getDomainName(), dimensionDomain.getPlanId(),
							dimensionDomain.getOriginalNum(), dimensionDomain.getReprintNum(), type));
				} catch (Exception e) {
					i++;
					logger.info("新增站点维度数据ID：" + dimensionDomain.getId() + "异常,已跳过...");
				}
			}
			logger.info(String.format("新增站点维度数据：%s条,报告类型：%s报,统计的方案ID：%s,信息开始日期：%s,信息结束日期%s,统计更新时间：%s",
					DimensionDomainList.size() - i, type, ifmIds.isEmpty() ? DBifmIds : ifmIds,
					StartTime != null ? format.format(StartTime) : format.format(date),
					endTime != null ? format.format(endTime) : format.format(date), format.format(DBTime)));
			return true;
		}

		return false;
	}

	/**
	 * 新增数据到方案详细排行维度统计表<br>
	 * ifmIds为Null默认统计所有方案 StatisticsTime 为Null默认统计时间为当前时间头一天零点开始到当前时间零点结束的信息
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean insterPlanRanking(List<Integer> ifmIds, Date StatisticsTime) throws NumberErrorException {
		List<DimensionPlanRanking> DimensionPlanRankingList = new ArrayList<DimensionPlanRanking>();// 方案转载排行维度
		Date DBTime = new Date();
		Long DBstartTime = ReportUtils.getStart(DBTime, 1);// 当前时间头一天零点
		Date date = new Date(DBstartTime);// 日志变量
		Long DBendTime = ReportUtils.getEnd(DBTime);// 当前时间零点
		List<Integer> DBifmIds = new ArrayList<Integer>();// 方案ID集合
		if (ifmIds.isEmpty()) {// 没有传入需要统计的方案就默认统计所有
			DBifmIds = iformationService.getAllId();// 获取所有的方案ID
			// 如果传入了时间，就统计传入时间当天零点至当天24点信息，没有传入就默认查询当前时间头一天零点开始到当前时间零点的信息
			DimensionPlanRankingList = mongo.StatisticsPlanRanking(InformationDistribute.class, DBifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		} else {
			DimensionPlanRankingList = mongo.StatisticsPlanRanking(InformationDistribute.class, ifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		}
		if (DimensionPlanRankingList.size() > 0) {
			// 删除老数据
			List<Long> idList = new ArrayList<Long>();
			for (DimensionPlanRanking DimensionPlanRankingId : DimensionPlanRankingList) {
				idList.add(DimensionPlanRankingId.getId());
			}
			if (idList != null && idList.size() > 0) {
				dimensionCountMapper.deletePlanRankingById(idList);
			}
			int i = 0;
			for (DimensionPlanRanking DimensionPlanRanking : DimensionPlanRankingList) {
				try {
					dimensionCountMapper.insertPlanRanking(DimensionPlanRanking);
				} catch (Exception e) {
					i++;
					logger.info("新增方案详细排行维度数据ID：" + DimensionPlanRanking.getId() + "异常,已跳过...");
				}
			}
			logger.info(String.format("新增方案详细排行维度数据：%s条,统计的方案ID：%s,信息日期：%s，统计更新时间：%s",
					DimensionPlanRankingList.size() - i, ifmIds.isEmpty() ? DBifmIds : ifmIds,
					StatisticsTime != null ? format.format(StatisticsTime) : format.format(date),
					format.format(DBTime)));
			return true;
		}
		return false;
	}

	/**
	 * 新增数据到渠道维度表<br>
	 * ifmIds为Null默认统计所有方案 StatisticsTime 为Null默认统计时间为当前时间头一天零点开始到当前时间零点结束的信息
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean insterChannel(List<Integer> ifmIds, Date StatisticsTime) throws NumberErrorException {
		List<DimensionChannel> DimensionChannelList = new ArrayList<DimensionChannel>();// 渠道维度
		Date DBTime = new Date();
		Long DBstartTime = ReportUtils.getStart(DBTime, 1);// 当前时间头一天零点
		Date date = new Date(DBstartTime);// 日志变量
		Long DBendTime = ReportUtils.getEnd(DBTime);// 当前时间零点
		List<Integer> DBifmIds = new ArrayList<Integer>();// 方案ID集合
		if (ifmIds.isEmpty()) {// 没有传入需要统计的方案就默认统计所有
			DBifmIds = iformationService.getAllId();// 获取所有的方案ID
			// 如果传入了时间，就统计传入时间当天零点至当天24点信息，没有传入就默认查询当前时间头一天零点开始到当前时间零点的信息
			DimensionChannelList = mongo.StatisticsChannel(InformationDistribute.class, DBifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		} else {
			DimensionChannelList = mongo.StatisticsChannel(InformationDistribute.class, ifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		}
		if (DimensionChannelList.size() > 0) {
			// 删除老数据
			List<Long> idList = new ArrayList<Long>();
			for (DimensionChannel DimensionChannelId : DimensionChannelList) {
				idList.add(DimensionChannelId.getId());
			}
			if (idList != null && idList.size() > 0) {
				dimensionCountMapper.deleteChannelById(idList);
			}
			int i = 0;
			for (DimensionChannel DimensionChannel : DimensionChannelList) {
				try {
					dimensionCountMapper.insertChannel(DimensionChannel);
				} catch (Exception e) {
					i++;
					logger.info("新增渠道维度数据ID：" + DimensionChannel.getId() + "异常,已跳过...");
				}
			}
			logger.info(String.format("新增渠道维度数据：%s条,统计的方案ID：%s,信息日期：%s，统计更新时间：%s", DimensionChannelList.size() - i,
					ifmIds.isEmpty() ? DBifmIds : ifmIds,
					StatisticsTime != null ? format.format(StatisticsTime) : format.format(date),
					format.format(DBTime)));
			return true;
		}
		return false;
	}

	/**
	 * 新增数据到方案维度表<br>
	 * ifmIds为Null默认统计所有方案 StatisticsTime 为Null默认统计时间为当前时间头一天零点开始到当前时间零点结束的信息
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean insterPlan(List<Integer> ifmIds, Date StatisticsTime) throws NumberErrorException {
		List<DimensionPlan> DimensionPlanList = new ArrayList<DimensionPlan>();// 方案维度
		Date DBTime = new Date();
		Long DBstartTime = ReportUtils.getStart(DBTime, 1);// 当前时间头一天零点
		Date date = new Date(DBstartTime);// 日志变量
		Long DBendTime = ReportUtils.getEnd(DBTime);// 当前时间零点
		List<Integer> DBifmIds = new ArrayList<Integer>();// 方案ID集合
		if (ifmIds.isEmpty()) {// 没有传入需要统计的方案就默认统计所有
			DBifmIds = iformationService.getAllId();// 获取所有的方案ID
			// 如果传入了时间，就统计传入时间当天零点至当天24点信息，没有传入就默认查询当前时间头一天零点开始到当前时间零点的信息
			DimensionPlanList = mongo.StatisticsDimensionPlan(InformationDistribute.class, DBifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		} else {
			DimensionPlanList = mongo.StatisticsDimensionPlan(InformationDistribute.class, ifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		}
		if (DimensionPlanList.size() > 0) {
			// 删除老数据
			List<Long> idList = new ArrayList<Long>();
			for (DimensionPlan DimensionPlanId : DimensionPlanList) {
				idList.add(DimensionPlanId.getId());
			}
			if (idList != null && idList.size() > 0) {
				dimensionCountMapper.deletePlanById(idList);
			}
			int i = 0;
			for (DimensionPlan DimensionPlan : DimensionPlanList) {
				try {
					dimensionCountMapper.insertPlan(DimensionPlan);
				} catch (Exception e) {
					i++;
					logger.info("新增方案维度数据ID：" + DimensionPlan.getId() + "异常,已跳过...");
				}
			}
			logger.info(String.format("新增方案维度数据：%s条,统计的方案ID：%s,信息日期：%s，统计更新时间：%s", DimensionPlanList.size() - i,
					ifmIds.isEmpty() ? DBifmIds : ifmIds,
					StatisticsTime != null ? format.format(StatisticsTime) : format.format(date),
					format.format(DBTime)));
			return true;
		}
		return false;
	}

	/**
	 * 新增数据到新闻排行维度统计表<br>
	 * ifmIds为Null默认统计所有方案 StatisticsTime 为Null默认统计时间为当前时间头一天零点开始到当前时间零点结束的信息
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean insterNewsRanking(List<Integer> ifmIds, Date StatisticsTime) throws NumberErrorException {
		List<DimensionNewsRanking> DimensionNewsRankingList = new ArrayList<DimensionNewsRanking>();// 方案新闻维度
		Date DBTime = new Date();
		Long DBstartTime = ReportUtils.getStart(DBTime, 1);// 当前时间头一天零点
		Date date = new Date(DBstartTime);// 日志变量
		Long DBendTime = ReportUtils.getEnd(DBTime);// 当前时间零点
		List<Integer> DBifmIds = new ArrayList<Integer>();// 方案ID集合
		if (ifmIds.isEmpty()) {// 没有传入需要统计的方案就默认统计所有
			DBifmIds = iformationService.getAllId();// 获取所有的方案ID
			// 如果传入了时间，就统计传入时间当天零点至当天24点信息，没有传入就默认查询当前时间头一天零点开始到当前时间零点的信息
			DimensionNewsRankingList = mongo.StatisticsNewsRanking(InformationDistribute.class, DBifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		} else {
			DimensionNewsRankingList = mongo.StatisticsNewsRanking(InformationDistribute.class, ifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		}
		if (DimensionNewsRankingList.size() > 0) {
			// 删除老数据
			List<Long> idList = new ArrayList<Long>();
			for (DimensionNewsRanking DimensionNewsRankingId : DimensionNewsRankingList) {
				idList.add(DimensionNewsRankingId.getId());
			}
			if (idList != null && idList.size() > 0) {
				dimensionCountMapper.deleteNewsRankingById(idList);
			}
			int i = 0;
			for (DimensionNewsRanking DimensionNewsRanking : DimensionNewsRankingList) {
				try {
					dimensionCountMapper.insertNewsRanking(DimensionNewsRanking);
				} catch (Exception e) {
					i++;
					logger.info("新增新闻排行维度数据ID：" + DimensionNewsRanking.getId() + "异常,已跳过...");
				}
			}
			logger.info(String.format("新增新闻排行维度数据：%s条,统计的方案ID：%s,信息日期：%s，统计更新时间：%s",
					DimensionNewsRankingList.size() - i, ifmIds.isEmpty() ? DBifmIds : ifmIds,
					StatisticsTime != null ? format.format(StatisticsTime) : format.format(date),
					format.format(DBTime)));
			return true;
		}
		return false;
	}

	/**
	 * 新增数据到微信排行维度统计表<br>
	 * ifmIds为Null默认统计所有方案 StatisticsTime 为Null默认统计时间为当前时间头一天零点开始到当前时间零点结束的信息
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean insterWeixinRanking(List<Integer> ifmIds, Date StatisticsTime) throws NumberErrorException {
		List<DimensionWeixinRanking> dimensionWeixinRankingList = new ArrayList<DimensionWeixinRanking>();// 方案新闻维度
		Date DBTime = new Date();
		Long DBstartTime = ReportUtils.getStart(DBTime, 1);// 当前时间头一天零点
		Date date = new Date(DBstartTime);// 日志变量
		Long DBendTime = ReportUtils.getEnd(DBTime);// 当前时间零点
		List<Integer> DBifmIds = new ArrayList<Integer>();// 方案ID集合
		if (ifmIds.isEmpty()) {// 没有传入需要统计的方案就默认统计所有
			DBifmIds = iformationService.getAllId();// 获取所有的方案ID
			// 如果传入了时间，就统计传入时间当天零点至当天24点信息，没有传入就默认查询当前时间头一天零点开始到当前时间零点的信息
			dimensionWeixinRankingList = mongo.StatisticsWeixinRanking(InformationDistribute.class, DBifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		} else {
			dimensionWeixinRankingList = mongo.StatisticsWeixinRanking(InformationDistribute.class, ifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		}
		if (dimensionWeixinRankingList.size() > 0) {
			// 删除老数据
			List<Long> idList = new ArrayList<Long>();
			for (DimensionWeixinRanking DimensionWeixinRankingId : dimensionWeixinRankingList) {
				idList.add(DimensionWeixinRankingId.getId());
			}
			if (idList != null && idList.size() > 0) {
				dimensionCountMapper.deleteWeixinRankingById(idList);
			}
			int i = 0;
			for (DimensionWeixinRanking DimensionWeixinRanking : dimensionWeixinRankingList) {
				try {
					dimensionCountMapper.insertWeixinRanking(DimensionWeixinRanking);
				} catch (Exception e) {
					i++;
					logger.info("新增微信排行维度数据ID：" + DimensionWeixinRanking.getId() + "异常,已跳过...");
				}
			}
			logger.info(String.format("新增微信排行维度数据：%s条,统计的方案ID：%s,信息日期：%s，统计更新时间：%s",
					dimensionWeixinRankingList.size() - i, ifmIds.isEmpty() ? DBifmIds : ifmIds,
					StatisticsTime != null ? format.format(StatisticsTime) : format.format(date),
					format.format(DBTime)));
			return true;
		}
		return false;
	}

	/**
	 * 新增数据到微博排行维度统计表<br>
	 * ifmIds为Null默认统计所有方案 StatisticsTime 为Null默认统计时间为当前时间头一天零点开始到当前时间零点结束的信息
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean insterWeiboRanking(List<Integer> ifmIds, Date StatisticsTime) throws NumberErrorException {
		List<DimensionWeiboRanking> dimensionWeiboRanking = new ArrayList<DimensionWeiboRanking>();// 方案新闻维度
		Date DBTime = new Date();
		Long DBstartTime = ReportUtils.getStart(DBTime, 1);// 当前时间头一天零点
		Date date = new Date(DBstartTime);// 日志变量
		Long DBendTime = ReportUtils.getEnd(DBTime);// 当前时间零点
		List<Integer> DBifmIds = new ArrayList<Integer>();// 方案ID集合
		if (ifmIds.isEmpty()) {// 没有传入需要统计的方案就默认统计所有
			DBifmIds = iformationService.getAllId();// 获取所有的方案ID
			// 如果传入了时间，就统计传入时间当天零点至当天24点信息，没有传入就默认查询当前时间头一天零点开始到当前时间零点的信息
			dimensionWeiboRanking = mongo.StatisticsWeiboRanking(InformationDistribute.class, DBifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		} else {
			dimensionWeiboRanking = mongo.StatisticsWeiboRanking(InformationDistribute.class, ifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		}
		if (dimensionWeiboRanking.size() > 0) {
			// 删除老数据
			List<Long> idList = new ArrayList<Long>();
			for (DimensionWeiboRanking DimensionWeiboRankingId : dimensionWeiboRanking) {
				idList.add(DimensionWeiboRankingId.getId());
			}
			if (idList != null && idList.size() > 0) {
				dimensionCountMapper.deleteWeiboRankingById(idList);
			}
			int i = 0;
			for (DimensionWeiboRanking DimensionWeiboRanking : dimensionWeiboRanking) {
				try {
					dimensionCountMapper.insertWeiboRanking(DimensionWeiboRanking);
				} catch (Exception e) {
					i++;
					logger.info("新增微博排行维度数据ID：" + DimensionWeiboRanking.getId() + "异常,已跳过...");
				}
			}
			logger.info(String.format("新增微博排行维度数据：%s条,统计的方案ID：%s,信息日期：%s，统计更新时间：%s", dimensionWeiboRanking.size() - i,
					ifmIds.isEmpty() ? DBifmIds : ifmIds,
					StatisticsTime != null ? format.format(StatisticsTime) : format.format(date),
					format.format(DBTime)));
			return true;
		}
		return false;
	}

	/**
	 * 新增数据到论坛排行维度统计表<br>
	 * ifmIds为Null默认统计所有方案 StatisticsTime 为Null默认统计时间为当前时间头一天零点开始到当前时间零点结束的信息
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean insterBbsRanking(List<Integer> ifmIds, Date StatisticsTime) throws NumberErrorException {
		List<DimensionBbsRanking> dimensionBbsRanking = new ArrayList<DimensionBbsRanking>();// 方案论坛维度
		Date DBTime = new Date();
		Long DBstartTime = ReportUtils.getStart(DBTime, 1);// 当前时间头一天零点
		Date date = new Date(DBstartTime);// 日志变量
		Long DBendTime = ReportUtils.getEnd(DBTime);// 当前时间零点
		List<Integer> DBifmIds = new ArrayList<Integer>();// 方案ID集合
		if (ifmIds.isEmpty()) {// 没有传入需要统计的方案就默认统计所有
			DBifmIds = iformationService.getAllId();// 获取所有的方案ID
			// 如果传入了时间，就统计传入时间当天零点至当天24点信息，没有传入就默认查询当前时间头一天零点开始到当前时间零点的信息
			dimensionBbsRanking = mongo.StatisticsBbsRanking(InformationDistribute.class, DBifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		} else {
			dimensionBbsRanking = mongo.StatisticsBbsRanking(InformationDistribute.class, ifmIds,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, 0) : DBstartTime,
					StatisticsTime != null ? ReportUtils.getStart(StatisticsTime, -1) : DBendTime);
		}
		if (dimensionBbsRanking.size() > 0) {
			// 删除老数据
			List<Long> idList = new ArrayList<Long>();
			for (DimensionBbsRanking DimensionBbsRanking : dimensionBbsRanking) {
				idList.add(DimensionBbsRanking.getId());
			}
			if (idList != null && idList.size() > 0) {
				dimensionCountMapper.deleteBbsRankingById(idList);
			}
			int i = 0;
			for (DimensionBbsRanking DimensionBbsRanking : dimensionBbsRanking) {
				try {
					dimensionCountMapper.insertBbsRanking(DimensionBbsRanking);
				} catch (Exception e) {
					i++;
					logger.info("新增论坛排行维度数据ID：" + DimensionBbsRanking.getId() + "异常,已跳过...");
				}
			}
			logger.info(String.format("新增论坛排行维度数据：%s条,统计的方案ID：%s,信息日期：%s，统计更新时间：%s", dimensionBbsRanking.size() - i,
					ifmIds.isEmpty() ? DBifmIds : ifmIds,
					StatisticsTime != null ? format.format(StatisticsTime) : format.format(date),
					format.format(DBTime)));
			return true;
		}
		return false;
	}

	/**
	 * 删除统计表数据 传入MAP Key:方案ID Value: 对应的时间 <br>
	 * 如果时间参数为NULL 则根据方案ID 来删除<br>
	 * 例子：Key:233,234 Value:2017-07-03 15:15:15,2017-07-02 15:15:15<br>
	 * 删除233,234方案下 17年7月3日、2日的所有统计信息。<br>
	 * 例子：Key:233,234 Value:Null<br>
	 * 删除233,234方案下所有统计信息。<br>
	 * 例子：Key:233,234 Value:2017-07-03 15:15:15,null<br>
	 * 删除233方案 17年7月3日 信息、删除234方案所有统计信息
	 * 
	 * @throws NumberErrorException
	 */
	@Override
	public boolean deleteStatistics(Map<Integer, Date> map) throws NumberErrorException {
		List<Long> idList = new ArrayList<Long>();// 用于存放数据的主键ID（不适用于方案统计表）
		List<Integer> ifmIds = new ArrayList<Integer>();// 用于存放需要删除的方案ID集合
		List<Long> ifmidList = new ArrayList<Long>();// 存放适用于方案统计表的ID集合
		int n = 0;// 方案ID集合方式删除变量
		int j = 0;// 主键ID集合方式删除变量
		if (!map.isEmpty()) {// Map 不为空 为三种List增加数据 Map为空 接口直接返回falst
			for (Map.Entry<Integer, Date> entry : map.entrySet()) {
				if (entry.getKey() != null) {// 方案ID不为Null
					// 时间为空 就按方案来删除
					if (entry.getValue() == null || entry.getValue().equals("")) {
						ifmIds.add(entry.getKey());
					} else {
						// 时间不为空 就按照ID来删除
						// 方案统计表ID生成规则
						ifmidList.add(ReportUtils.buildId(entry.getValue(), entry.getKey(), 1));
						// 站点统计表、渠道统计表、方案排行表、新闻排行表、微信排行表、微博排行表、论坛排行表ID生成规则
						for (int i = 1; i < 11; i++) {
							idList.add(ReportUtils.buildId(entry.getValue(), entry.getKey(), i));// 日报ID
							idList.add(ReportUtils.buildId(entry.getValue(), entry.getKey(), i, Cycle.WEEK.getCode()));// 周报ID
							idList.add(ReportUtils.buildId(entry.getValue(), entry.getKey(), i, Cycle.MONTH.getCode()));// 月报ID
						}
					}
				}
			}
		}
		if (ifmIds.size() > 0) {
			/**
			 * 方案ID集合方式删除
			 */
			n = dimensionCountMapper.deleteDomainByPlan(ifmIds);// 站点统计表

			n = dimensionCountMapper.deleteChannelByPlan(ifmIds);// 渠道统计表

			n = dimensionCountMapper.deletePlanRankingByPlan(ifmIds);// 方案详细排行

			n = dimensionCountMapper.deleteNewsRankingByPlan(ifmIds);// 新闻排行表

			n = dimensionCountMapper.deleteWeixinRankingByPlan(ifmIds);// 微信排行表

			n = dimensionCountMapper.deleteWeiboRankingByPlan(ifmIds);// 微博排行表

			n = dimensionCountMapper.deleteBbsRankingByPlan(ifmIds);// 论坛排行表

			n = dimensionCountMapper.deletePlanByplan(ifmIds);// 方案统计表
		}
		if (idList.size() > 0) {
			/**
			 * 主键ID集合方式删除
			 */
			j = dimensionCountMapper.deleteDomainById(idList);// 站点统计表

			j = dimensionCountMapper.deleteChannelById(idList);// 渠道统计表

			j = dimensionCountMapper.deletePlanRankingById(idList);// 方案详细排行

			j = dimensionCountMapper.deleteNewsRankingById(idList);// 新闻排行表

			j = dimensionCountMapper.deleteWeixinRankingById(idList);// 微信排行表

			j = dimensionCountMapper.deleteWeiboRankingById(idList);// 微博排行表

			j = dimensionCountMapper.deleteBbsRankingById(idList);// 论坛排行表
		}
		if (ifmidList.size() > 0) {
			/**
			 * 主键ID集合方式删除
			 */
			n = dimensionCountMapper.deletePlanById(ifmidList);// 方案统计表
		}

		return (n + j) > 0;
	}

	@Override
	public boolean deleteAndInsterStatistics(Map<Integer, Date> map) throws NumberErrorException {
//		if (deleteStatistics(map)) {
		if(!map.isEmpty()){
			List<Integer> ifmIds = new ArrayList<Integer>();
			Date StartTime = null;
			Date endTime = null;
			Date nowDate = new Date();
			logger.info("-------------开始尝试重新统计数据！------------------");
			for (Map.Entry<Integer, Date> entry : map.entrySet()) {
				if (entry.getKey() != null && entry.getValue() != null) {// 方案ID不为Null
					ifmIds.add(entry.getKey());
					insterPlanRanking(ifmIds, entry.getValue());
					insterChannel(ifmIds, entry.getValue());
					insterPlan(ifmIds, entry.getValue());
					insterNewsRanking(ifmIds, entry.getValue());
					insterWeixinRanking(ifmIds, entry.getValue());
					insterWeiboRanking(ifmIds, entry.getValue());
					insterBbsRanking(ifmIds, entry.getValue());
					insterDimensionDomain(ifmIds, entry.getValue(), entry.getValue(), Cycle.DAY.getCode());// 站点的日报维度数据
					Calendar cal = Calendar.getInstance();
					cal.setTime(entry.getValue());
					// 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
					int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
					if (1 == dayWeek) {
						cal.add(Calendar.DAY_OF_MONTH, -1);
					}
					cal.setFirstDayOfWeek(Calendar.MONDAY);// 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
					int day = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
					cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);// 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
					StartTime = cal.getTime(); // 所在周星期一的日期
					cal.add(Calendar.DATE, 7); // 这里取7为下周一6为本周日
					endTime = cal.getTime(); // 所在周日期为周一的凌晨
					// 判断这个时间段是否已经生成过周报
					// 比较当前时间
					if (endTime.getTime() < nowDate.getTime()) {
						// 判断上个循环是否生成过周报
						if (!selectDomainId(
								ReportUtils.buildId(entry.getValue(), entry.getKey(), 1, Cycle.WEEK.getCode()))) {// 一个就行
							insterDimensionDomain(ifmIds, StartTime, endTime, Cycle.WEEK.getCode());// 站点的周报维度数据
						}
					}
//					-----------------统计完八月记得解开注释-----------------------
					Calendar calendar = Calendar.getInstance();
					calendar.setTime(entry.getValue());
					calendar.set(Calendar.DAY_OF_MONTH, 1);
					Date firstDayOfMonth = calendar.getTime();
					calendar.add(Calendar.MONTH, 1);
					calendar.add(Calendar.DAY_OF_MONTH, 0);
					Date lastDayOfMonth = calendar.getTime();
					// 判断这个时间段是否已经生成过月报
					// 比较当前时间
					if (lastDayOfMonth.getTime() < nowDate.getTime()) {
						// 判断上个循环是否生成过月报
						if (!selectDomainId(
								ReportUtils.buildId(entry.getValue(), entry.getKey(), 1, Cycle.MONTH.getCode()))) {// 一个就行
							insterDimensionDomain(ifmIds, firstDayOfMonth, lastDayOfMonth, Cycle.MONTH.getCode());// 站点的月报维度数据
						}
					}
					//-----------------统计完八月记得解开注释-----------------------
					ifmIds.clear();
				} else {
					logger.info("重新统计发现方案ID或时间参数为null，无法统计！");
				}
			}
			logger.info("------------------重新统计数据完成！--------------------");
			return true;
		}
		logger.info("重新统计入参map为空！");
		return false;
	}

	public static void main(String[] args) {
		// convertWeekByDate(new Date());
		dd();
	}

	@Override
	public boolean selectDomainId(Long id) {
		return dimensionCountMapper.selectDomainId(id) > 0;
	}

	@SuppressWarnings("unused")
	private static void convertWeekByDate(Date time) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd 00:00:00");
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(new Date());// 设置当前日期
		// calendar.add(Calendar.MONTH, -1);//月份减一
		// System.out.println(sdf.format(calendar.getTime()));//输出上个月的日期

		// calendar.setTime(date);
		calendar.set(Calendar.DAY_OF_MONTH, 1);
		Date firstDayOfMonth = calendar.getTime();
		calendar.add(Calendar.MONTH, 1);
		calendar.add(Calendar.DAY_OF_MONTH, 0);
		Date lastDayOfMonth = calendar.getTime();
		System.out.println(sdf.format(firstDayOfMonth));
		System.out.println(sdf.format(lastDayOfMonth));

	}

	/**
	 * List 去重
	 */
	public static void dd() {
//		Calendar calendar = Calendar.getInstance();
//		calendar.setTime(new Date());// 设置当前日期
//		calendar.set(Calendar.DAY_OF_MONTH, 1);
//		Date firstDayOfMonth = calendar.getTime();
//		List<InformationDistribute> list = new ArrayList<>();
//		InformationDistribute informationDistribute = new InformationDistribute();
//		informationDistribute.setIfmId("233");
//		informationDistribute.setArticleId("66666");
//		informationDistribute.setReleaseTime(new Date());
//		InformationDistribute informationDistribute2 = new InformationDistribute();
//		informationDistribute2.setIfmId("233");
//		informationDistribute.setArticleId("77777");
//		 informationDistribute2.setReleaseTime(new Date());
//		InformationDistribute informationDistribute3 = new InformationDistribute();
//		informationDistribute3.setIfmId("234");
//		informationDistribute.setArticleId("66666");
//		// informationDistribute3.setReleaseTime(new Date());
//		InformationDistribute informationDistribute5 = new InformationDistribute();
//		informationDistribute5.setIfmId("234");
//		informationDistribute.setArticleId("77777");
//		// informationDistribute5.setReleaseTime(new Date());
//		InformationDistribute informationDistribute6 = new InformationDistribute();
//		informationDistribute6.setIfmId("234");
//		informationDistribute6.setReleaseTime(firstDayOfMonth);
//		list.add(informationDistribute);
//		list.add(informationDistribute2);
//		list.add(informationDistribute3);
//		list.add(informationDistribute5);
//		list.add(informationDistribute6);
//		Set<InformationDistribute> set = new HashSet<InformationDistribute>(list);
//		for (InformationDistribute informationDistribute4 : set) {
//			System.out.println(informationDistribute4.toString());
//		}
	}

	// public static Map<String, String> doThing(Map<String, String> map) {
	// Map<String, String> map2 = new HashMap<String, String>();
	// Map<String, String> map3 = new HashMap<String, String>();
	// // TreeMap:对map按key值排序
	// TreeMap<String, String> treemap = new TreeMap<String, String>(map);
	// Iterator<String> it = treemap.keySet().iterator();
	// while (it.hasNext()) {
	// String key = it.next();
	// String value = treemap.get(key);
	// if (map2.containsKey(value)) {
	// continue;
	// } else {
	// map2.put(value, value);
	// map3.put(key, value);
	// }
	//
	// }
	// return map3;
	// }

}
